//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2021 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto/tree/main/CodeGenerator. DO NOT EDIT.

import Foundation
import SotoCore

extension EKS {
    // MARK: Enums

    public enum AMITypes: String, CustomStringConvertible, Codable {
        case al2Arm64 = "AL2_ARM_64"
        case al2X8664 = "AL2_x86_64"
        case al2X8664Gpu = "AL2_x86_64_GPU"
        public var description: String { return self.rawValue }
    }

    public enum AddonIssueCode: String, CustomStringConvertible, Codable {
        case accessdenied = "AccessDenied"
        case clusterunreachable = "ClusterUnreachable"
        case configurationconflict = "ConfigurationConflict"
        case insufficientnumberofreplicas = "InsufficientNumberOfReplicas"
        case internalfailure = "InternalFailure"
        public var description: String { return self.rawValue }
    }

    public enum AddonStatus: String, CustomStringConvertible, Codable {
        case active = "ACTIVE"
        case createFailed = "CREATE_FAILED"
        case creating = "CREATING"
        case degraded = "DEGRADED"
        case deleteFailed = "DELETE_FAILED"
        case deleting = "DELETING"
        case updating = "UPDATING"
        public var description: String { return self.rawValue }
    }

    public enum CapacityTypes: String, CustomStringConvertible, Codable {
        case onDemand = "ON_DEMAND"
        case spot = "SPOT"
        public var description: String { return self.rawValue }
    }

    public enum ClusterStatus: String, CustomStringConvertible, Codable {
        case active = "ACTIVE"
        case creating = "CREATING"
        case deleting = "DELETING"
        case failed = "FAILED"
        case updating = "UPDATING"
        public var description: String { return self.rawValue }
    }

    public enum ErrorCode: String, CustomStringConvertible, Codable {
        case accessdenied = "AccessDenied"
        case clusterunreachable = "ClusterUnreachable"
        case configurationconflict = "ConfigurationConflict"
        case enilimitreached = "EniLimitReached"
        case insufficientfreeaddresses = "InsufficientFreeAddresses"
        case insufficientnumberofreplicas = "InsufficientNumberOfReplicas"
        case ipnotavailable = "IpNotAvailable"
        case nodecreationfailure = "NodeCreationFailure"
        case operationnotpermitted = "OperationNotPermitted"
        case podevictionfailure = "PodEvictionFailure"
        case securitygroupnotfound = "SecurityGroupNotFound"
        case subnetnotfound = "SubnetNotFound"
        case unknown = "Unknown"
        case vpcidnotfound = "VpcIdNotFound"
        public var description: String { return self.rawValue }
    }

    public enum FargateProfileStatus: String, CustomStringConvertible, Codable {
        case active = "ACTIVE"
        case createFailed = "CREATE_FAILED"
        case creating = "CREATING"
        case deleteFailed = "DELETE_FAILED"
        case deleting = "DELETING"
        public var description: String { return self.rawValue }
    }

    public enum LogType: String, CustomStringConvertible, Codable {
        case api
        case audit
        case authenticator
        case controllermanager = "controllerManager"
        case scheduler
        public var description: String { return self.rawValue }
    }

    public enum NodegroupIssueCode: String, CustomStringConvertible, Codable {
        case accessdenied = "AccessDenied"
        case asginstancelaunchfailures = "AsgInstanceLaunchFailures"
        case autoscalinggroupinvalidconfiguration = "AutoScalingGroupInvalidConfiguration"
        case autoscalinggroupnotfound = "AutoScalingGroupNotFound"
        case clusterunreachable = "ClusterUnreachable"
        case ec2launchtemplatenotfound = "Ec2LaunchTemplateNotFound"
        case ec2launchtemplateversionmismatch = "Ec2LaunchTemplateVersionMismatch"
        case ec2securitygroupdeletionfailure = "Ec2SecurityGroupDeletionFailure"
        case ec2securitygroupnotfound = "Ec2SecurityGroupNotFound"
        case ec2subnetinvalidconfiguration = "Ec2SubnetInvalidConfiguration"
        case ec2subnetnotfound = "Ec2SubnetNotFound"
        case iaminstanceprofilenotfound = "IamInstanceProfileNotFound"
        case iamlimitexceeded = "IamLimitExceeded"
        case iamnoderolenotfound = "IamNodeRoleNotFound"
        case instancelimitexceeded = "InstanceLimitExceeded"
        case insufficientfreeaddresses = "InsufficientFreeAddresses"
        case internalfailure = "InternalFailure"
        case nodecreationfailure = "NodeCreationFailure"
        public var description: String { return self.rawValue }
    }

    public enum NodegroupStatus: String, CustomStringConvertible, Codable {
        case active = "ACTIVE"
        case createFailed = "CREATE_FAILED"
        case creating = "CREATING"
        case degraded = "DEGRADED"
        case deleteFailed = "DELETE_FAILED"
        case deleting = "DELETING"
        case updating = "UPDATING"
        public var description: String { return self.rawValue }
    }

    public enum ResolveConflicts: String, CustomStringConvertible, Codable {
        case none = "NONE"
        case overwrite = "OVERWRITE"
        public var description: String { return self.rawValue }
    }

    public enum UpdateParamType: String, CustomStringConvertible, Codable {
        case addonversion = "AddonVersion"
        case clusterlogging = "ClusterLogging"
        case desiredsize = "DesiredSize"
        case encryptionconfig = "EncryptionConfig"
        case endpointprivateaccess = "EndpointPrivateAccess"
        case endpointpublicaccess = "EndpointPublicAccess"
        case identityproviderconfig = "IdentityProviderConfig"
        case labelstoadd = "LabelsToAdd"
        case labelstoremove = "LabelsToRemove"
        case maxsize = "MaxSize"
        case minsize = "MinSize"
        case platformversion = "PlatformVersion"
        case publicaccesscidrs = "PublicAccessCidrs"
        case releaseversion = "ReleaseVersion"
        case resolveconflicts = "ResolveConflicts"
        case serviceaccountrolearn = "ServiceAccountRoleArn"
        case version = "Version"
        public var description: String { return self.rawValue }
    }

    public enum UpdateStatus: String, CustomStringConvertible, Codable {
        case cancelled = "Cancelled"
        case failed = "Failed"
        case inprogress = "InProgress"
        case successful = "Successful"
        public var description: String { return self.rawValue }
    }

    public enum UpdateType: String, CustomStringConvertible, Codable {
        case addonupdate = "AddonUpdate"
        case associateencryptionconfig = "AssociateEncryptionConfig"
        case associateidentityproviderconfig = "AssociateIdentityProviderConfig"
        case configupdate = "ConfigUpdate"
        case disassociateidentityproviderconfig = "DisassociateIdentityProviderConfig"
        case endpointaccessupdate = "EndpointAccessUpdate"
        case loggingupdate = "LoggingUpdate"
        case versionupdate = "VersionUpdate"
        public var description: String { return self.rawValue }
    }

    public enum ConfigStatus: String, CustomStringConvertible, Codable {
        case active = "ACTIVE"
        case creating = "CREATING"
        case deleting = "DELETING"
        public var description: String { return self.rawValue }
    }

    // MARK: Shapes

    public struct Addon: AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the add-on.
        public let addonArn: String?
        /// The name of the add-on.
        public let addonName: String?
        /// The version of the add-on.
        public let addonVersion: String?
        /// The name of the cluster.
        public let clusterName: String?
        /// The date and time that the add-on was created.
        public let createdAt: Date?
        /// An object that represents the health of the add-on.
        public let health: AddonHealth?
        /// The date and time that the add-on was last modified.
        public let modifiedAt: Date?
        /// The Amazon Resource Name (ARN) of the IAM role that is bound to the Kubernetes service account used by the add-on.
        public let serviceAccountRoleArn: String?
        /// The status of the add-on.
        public let status: AddonStatus?
        /// The metadata that you apply to the cluster to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define. Cluster tags do not propagate to any other resources associated with the cluster.
        public let tags: [String: String]?

        public init(addonArn: String? = nil, addonName: String? = nil, addonVersion: String? = nil, clusterName: String? = nil, createdAt: Date? = nil, health: AddonHealth? = nil, modifiedAt: Date? = nil, serviceAccountRoleArn: String? = nil, status: AddonStatus? = nil, tags: [String: String]? = nil) {
            self.addonArn = addonArn
            self.addonName = addonName
            self.addonVersion = addonVersion
            self.clusterName = clusterName
            self.createdAt = createdAt
            self.health = health
            self.modifiedAt = modifiedAt
            self.serviceAccountRoleArn = serviceAccountRoleArn
            self.status = status
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case addonArn
            case addonName
            case addonVersion
            case clusterName
            case createdAt
            case health
            case modifiedAt
            case serviceAccountRoleArn
            case status
            case tags
        }
    }

    public struct AddonHealth: AWSDecodableShape {
        /// An object that represents the add-on's health issues.
        public let issues: [AddonIssue]?

        public init(issues: [AddonIssue]? = nil) {
            self.issues = issues
        }

        private enum CodingKeys: String, CodingKey {
            case issues
        }
    }

    public struct AddonInfo: AWSDecodableShape {
        /// The name of the add-on.
        public let addonName: String?
        /// An object that represents information about available add-on versions and compatible Kubernetes versions.
        public let addonVersions: [AddonVersionInfo]?
        /// The type of the add-on.
        public let type: String?

        public init(addonName: String? = nil, addonVersions: [AddonVersionInfo]? = nil, type: String? = nil) {
            self.addonName = addonName
            self.addonVersions = addonVersions
            self.type = type
        }

        private enum CodingKeys: String, CodingKey {
            case addonName
            case addonVersions
            case type
        }
    }

    public struct AddonIssue: AWSDecodableShape {
        /// A code that describes the type of issue.
        public let code: AddonIssueCode?
        /// A message that provides details about the issue and what might cause it.
        public let message: String?
        /// The resource IDs of the issue.
        public let resourceIds: [String]?

        public init(code: AddonIssueCode? = nil, message: String? = nil, resourceIds: [String]? = nil) {
            self.code = code
            self.message = message
            self.resourceIds = resourceIds
        }

        private enum CodingKeys: String, CodingKey {
            case code
            case message
            case resourceIds
        }
    }

    public struct AddonVersionInfo: AWSDecodableShape {
        /// The version of the add-on.
        public let addonVersion: String?
        /// The architectures that the version supports.
        public let architecture: [String]?
        /// An object that represents the compatibilities of a version.
        public let compatibilities: [Compatibility]?

        public init(addonVersion: String? = nil, architecture: [String]? = nil, compatibilities: [Compatibility]? = nil) {
            self.addonVersion = addonVersion
            self.architecture = architecture
            self.compatibilities = compatibilities
        }

        private enum CodingKeys: String, CodingKey {
            case addonVersion
            case architecture
            case compatibilities
        }
    }

    public struct AssociateEncryptionConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// The client request token you are using with the encryption configuration.
        public let clientRequestToken: String?
        /// The name of the cluster that you are associating with encryption configuration.
        public let clusterName: String
        /// The configuration you are using for encryption.
        public let encryptionConfig: [EncryptionConfig]

        public init(clientRequestToken: String? = AssociateEncryptionConfigRequest.idempotencyToken(), clusterName: String, encryptionConfig: [EncryptionConfig]) {
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.encryptionConfig = encryptionConfig
        }

        public func validate(name: String) throws {
            try self.validate(self.encryptionConfig, name: "encryptionConfig", parent: name, max: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case encryptionConfig
        }
    }

    public struct AssociateEncryptionConfigResponse: AWSDecodableShape {
        public let update: Update?

        public init(update: Update? = nil) {
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case update
        }
    }

    public struct AssociateIdentityProviderConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the cluster to associate the configuration to.
        public let clusterName: String
        /// An object that represents an OpenID Connect (OIDC) identity provider configuration.
        public let oidc: OidcIdentityProviderConfigRequest
        /// The metadata to apply to the configuration to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define.
        public let tags: [String: String]?

        public init(clientRequestToken: String? = AssociateIdentityProviderConfigRequest.idempotencyToken(), clusterName: String, oidc: OidcIdentityProviderConfigRequest, tags: [String: String]? = nil) {
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.oidc = oidc
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.oidc.validate(name: "\(name).oidc")
            try self.tags?.forEach {
                try validate($0.key, name: "tags.key", parent: name, max: 128)
                try validate($0.key, name: "tags.key", parent: name, min: 1)
                try validate($0.value, name: "tags[\"\($0.key)\"]", parent: name, max: 256)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case oidc
            case tags
        }
    }

    public struct AssociateIdentityProviderConfigResponse: AWSDecodableShape {
        /// The tags for the resource.
        public let tags: [String: String]?
        public let update: Update?

        public init(tags: [String: String]? = nil, update: Update? = nil) {
            self.tags = tags
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case tags
            case update
        }
    }

    public struct AutoScalingGroup: AWSDecodableShape {
        /// The name of the Auto Scaling group associated with an Amazon EKS managed node group.
        public let name: String?

        public init(name: String? = nil) {
            self.name = name
        }

        private enum CodingKeys: String, CodingKey {
            case name
        }
    }

    public struct Certificate: AWSDecodableShape {
        /// The Base64-encoded certificate data required to communicate with your cluster. Add this to the certificate-authority-data section of the kubeconfig file for your cluster.
        public let data: String?

        public init(data: String? = nil) {
            self.data = data
        }

        private enum CodingKeys: String, CodingKey {
            case data
        }
    }

    public struct Cluster: AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the cluster.
        public let arn: String?
        /// The certificate-authority-data for your cluster.
        public let certificateAuthority: Certificate?
        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The Unix epoch timestamp in seconds for when the cluster was created.
        public let createdAt: Date?
        /// The encryption configuration for the cluster.
        public let encryptionConfig: [EncryptionConfig]?
        /// The endpoint for your Kubernetes API server.
        public let endpoint: String?
        /// The identity provider information for the cluster.
        public let identity: Identity?
        /// The Kubernetes network configuration for the cluster.
        public let kubernetesNetworkConfig: KubernetesNetworkConfigResponse?
        /// The logging configuration for your cluster.
        public let logging: Logging?
        /// The name of the cluster.
        public let name: String?
        /// The platform version of your Amazon EKS cluster. For more information, see Platform Versions in the  Amazon EKS User Guide .
        public let platformVersion: String?
        /// The VPC configuration used by the cluster control plane. Amazon EKS VPC resources have specific requirements to work properly with Kubernetes. For more information, see Cluster VPC Considerations and Cluster Security Group Considerations in the Amazon EKS User Guide.
        public let resourcesVpcConfig: VpcConfigResponse?
        /// The Amazon Resource Name (ARN) of the IAM role that provides permissions for the Kubernetes control plane to make calls to AWS API operations on your behalf.
        public let roleArn: String?
        /// The current status of the cluster.
        public let status: ClusterStatus?
        /// The metadata that you apply to the cluster to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define. Cluster tags do not propagate to any other resources associated with the cluster.
        public let tags: [String: String]?
        /// The Kubernetes server version for the cluster.
        public let version: String?

        public init(arn: String? = nil, certificateAuthority: Certificate? = nil, clientRequestToken: String? = nil, createdAt: Date? = nil, encryptionConfig: [EncryptionConfig]? = nil, endpoint: String? = nil, identity: Identity? = nil, kubernetesNetworkConfig: KubernetesNetworkConfigResponse? = nil, logging: Logging? = nil, name: String? = nil, platformVersion: String? = nil, resourcesVpcConfig: VpcConfigResponse? = nil, roleArn: String? = nil, status: ClusterStatus? = nil, tags: [String: String]? = nil, version: String? = nil) {
            self.arn = arn
            self.certificateAuthority = certificateAuthority
            self.clientRequestToken = clientRequestToken
            self.createdAt = createdAt
            self.encryptionConfig = encryptionConfig
            self.endpoint = endpoint
            self.identity = identity
            self.kubernetesNetworkConfig = kubernetesNetworkConfig
            self.logging = logging
            self.name = name
            self.platformVersion = platformVersion
            self.resourcesVpcConfig = resourcesVpcConfig
            self.roleArn = roleArn
            self.status = status
            self.tags = tags
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case arn
            case certificateAuthority
            case clientRequestToken
            case createdAt
            case encryptionConfig
            case endpoint
            case identity
            case kubernetesNetworkConfig
            case logging
            case name
            case platformVersion
            case resourcesVpcConfig
            case roleArn
            case status
            case tags
            case version
        }
    }

    public struct Compatibility: AWSDecodableShape {
        /// The supported Kubernetes version of the cluster.
        public let clusterVersion: String?
        /// The supported default version.
        public let defaultVersion: Bool?
        /// The supported compute platform.
        public let platformVersions: [String]?

        public init(clusterVersion: String? = nil, defaultVersion: Bool? = nil, platformVersions: [String]? = nil) {
            self.clusterVersion = clusterVersion
            self.defaultVersion = defaultVersion
            self.platformVersions = platformVersions
        }

        private enum CodingKeys: String, CodingKey {
            case clusterVersion
            case defaultVersion
            case platformVersions
        }
    }

    public struct CreateAddonRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// The name of the add-on. The name must match one of the names returned by  ListAddons .
        public let addonName: String
        /// The version of the add-on. The version must match one of the versions returned by  DescribeAddonVersions .
        public let addonVersion: String?
        /// A unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the cluster to create the add-on for.
        public let clusterName: String
        /// How to resolve parameter value conflicts when migrating an existing add-on to an Amazon EKS add-on.
        public let resolveConflicts: ResolveConflicts?
        /// The Amazon Resource Name (ARN) of an existing IAM role to bind to the add-on's service account. The role must be assigned the IAM permissions required by the add-on. If you don't specify an existing IAM role, then the add-on uses the permissions assigned to the node IAM role. For more information, see Amazon EKS node IAM role in the Amazon EKS User Guide.  To specify an existing IAM role, you must have an IAM OpenID Connect (OIDC) provider created for your cluster. For more information, see Enabling IAM roles for service accounts on your cluster in the Amazon EKS User Guide.
        public let serviceAccountRoleArn: String?
        /// The metadata to apply to the cluster to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define.
        public let tags: [String: String]?

        public init(addonName: String, addonVersion: String? = nil, clientRequestToken: String? = CreateAddonRequest.idempotencyToken(), clusterName: String, resolveConflicts: ResolveConflicts? = nil, serviceAccountRoleArn: String? = nil, tags: [String: String]? = nil) {
            self.addonName = addonName
            self.addonVersion = addonVersion
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.resolveConflicts = resolveConflicts
            self.serviceAccountRoleArn = serviceAccountRoleArn
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterName, name: "clusterName", parent: name, max: 100)
            try self.validate(self.clusterName, name: "clusterName", parent: name, min: 1)
            try self.validate(self.clusterName, name: "clusterName", parent: name, pattern: "^[0-9A-Za-z][A-Za-z0-9\\-_]*")
            try self.validate(self.serviceAccountRoleArn, name: "serviceAccountRoleArn", parent: name, max: 255)
            try self.validate(self.serviceAccountRoleArn, name: "serviceAccountRoleArn", parent: name, min: 1)
            try self.tags?.forEach {
                try validate($0.key, name: "tags.key", parent: name, max: 128)
                try validate($0.key, name: "tags.key", parent: name, min: 1)
                try validate($0.value, name: "tags[\"\($0.key)\"]", parent: name, max: 256)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case addonName
            case addonVersion
            case clientRequestToken
            case resolveConflicts
            case serviceAccountRoleArn
            case tags
        }
    }

    public struct CreateAddonResponse: AWSDecodableShape {
        public let addon: Addon?

        public init(addon: Addon? = nil) {
            self.addon = addon
        }

        private enum CodingKeys: String, CodingKey {
            case addon
        }
    }

    public struct CreateClusterRequest: AWSEncodableShape {
        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The encryption configuration for the cluster.
        public let encryptionConfig: [EncryptionConfig]?
        /// The Kubernetes network configuration for the cluster.
        public let kubernetesNetworkConfig: KubernetesNetworkConfigRequest?
        /// Enable or disable exporting the Kubernetes control plane logs for your cluster to CloudWatch Logs. By default, cluster control plane logs aren't exported to CloudWatch Logs. For more information, see Amazon EKS Cluster Control Plane Logs in the  Amazon EKS User Guide .  CloudWatch Logs ingestion, archive storage, and data scanning rates apply to exported control plane logs. For more information, see Amazon CloudWatch Pricing.
        public let logging: Logging?
        /// The unique name to give to your cluster.
        public let name: String
        /// The VPC configuration used by the cluster control plane. Amazon EKS VPC resources have specific requirements to work properly with Kubernetes. For more information, see Cluster VPC Considerations and Cluster Security Group Considerations in the Amazon EKS User Guide. You must specify at least two subnets. You can specify up to five security groups, but we recommend that you use a dedicated security group for your cluster control plane.
        public let resourcesVpcConfig: VpcConfigRequest
        /// The Amazon Resource Name (ARN) of the IAM role that provides permissions for the Kubernetes control plane to make calls to AWS API operations on your behalf. For more information, see Amazon EKS Service IAM Role in the  Amazon EKS User Guide .
        public let roleArn: String
        /// The metadata to apply to the cluster to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define.
        public let tags: [String: String]?
        /// The desired Kubernetes version for your cluster. If you don't specify a value here, the latest version available in Amazon EKS is used.
        public let version: String?

        public init(clientRequestToken: String? = CreateClusterRequest.idempotencyToken(), encryptionConfig: [EncryptionConfig]? = nil, kubernetesNetworkConfig: KubernetesNetworkConfigRequest? = nil, logging: Logging? = nil, name: String, resourcesVpcConfig: VpcConfigRequest, roleArn: String, tags: [String: String]? = nil, version: String? = nil) {
            self.clientRequestToken = clientRequestToken
            self.encryptionConfig = encryptionConfig
            self.kubernetesNetworkConfig = kubernetesNetworkConfig
            self.logging = logging
            self.name = name
            self.resourcesVpcConfig = resourcesVpcConfig
            self.roleArn = roleArn
            self.tags = tags
            self.version = version
        }

        public func validate(name: String) throws {
            try self.validate(self.encryptionConfig, name: "encryptionConfig", parent: name, max: 1)
            try self.validate(self.name, name: "name", parent: name, max: 100)
            try self.validate(self.name, name: "name", parent: name, min: 1)
            try self.validate(self.name, name: "name", parent: name, pattern: "^[0-9A-Za-z][A-Za-z0-9\\-_]*")
            try self.tags?.forEach {
                try validate($0.key, name: "tags.key", parent: name, max: 128)
                try validate($0.key, name: "tags.key", parent: name, min: 1)
                try validate($0.value, name: "tags[\"\($0.key)\"]", parent: name, max: 256)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case encryptionConfig
            case kubernetesNetworkConfig
            case logging
            case name
            case resourcesVpcConfig
            case roleArn
            case tags
            case version
        }
    }

    public struct CreateClusterResponse: AWSDecodableShape {
        /// The full description of your new cluster.
        public let cluster: Cluster?

        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster
        }
    }

    public struct CreateFargateProfileRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the Amazon EKS cluster to apply the Fargate profile to.
        public let clusterName: String
        /// The name of the Fargate profile.
        public let fargateProfileName: String
        /// The Amazon Resource Name (ARN) of the pod execution role to use for pods that match the selectors in the Fargate profile. The pod execution role allows Fargate infrastructure to register with your cluster as a node, and it provides read access to Amazon ECR image repositories. For more information, see Pod Execution Role in the Amazon EKS User Guide.
        public let podExecutionRoleArn: String
        /// The selectors to match for pods to use this Fargate profile. Each selector must have an associated namespace. Optionally, you can also specify labels for a namespace. You may specify up to five selectors in a Fargate profile.
        public let selectors: [FargateProfileSelector]?
        /// The IDs of subnets to launch your pods into. At this time, pods running on Fargate are not assigned public IP addresses, so only private subnets (with no direct route to an Internet Gateway) are accepted for this parameter.
        public let subnets: [String]?
        /// The metadata to apply to the Fargate profile to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define. Fargate profile tags do not propagate to any other resources associated with the Fargate profile, such as the pods that are scheduled with it.
        public let tags: [String: String]?

        public init(clientRequestToken: String? = CreateFargateProfileRequest.idempotencyToken(), clusterName: String, fargateProfileName: String, podExecutionRoleArn: String, selectors: [FargateProfileSelector]? = nil, subnets: [String]? = nil, tags: [String: String]? = nil) {
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.fargateProfileName = fargateProfileName
            self.podExecutionRoleArn = podExecutionRoleArn
            self.selectors = selectors
            self.subnets = subnets
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.tags?.forEach {
                try validate($0.key, name: "tags.key", parent: name, max: 128)
                try validate($0.key, name: "tags.key", parent: name, min: 1)
                try validate($0.value, name: "tags[\"\($0.key)\"]", parent: name, max: 256)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case fargateProfileName
            case podExecutionRoleArn
            case selectors
            case subnets
            case tags
        }
    }

    public struct CreateFargateProfileResponse: AWSDecodableShape {
        /// The full description of your new Fargate profile.
        public let fargateProfile: FargateProfile?

        public init(fargateProfile: FargateProfile? = nil) {
            self.fargateProfile = fargateProfile
        }

        private enum CodingKeys: String, CodingKey {
            case fargateProfile
        }
    }

    public struct CreateNodegroupRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// The AMI type for your node group. GPU instance types should use the AL2_x86_64_GPU AMI type. Non-GPU instances should use the AL2_x86_64 AMI type. Arm instances should use the AL2_ARM_64 AMI type. All types use the Amazon EKS optimized Amazon Linux 2 AMI. If you specify launchTemplate, and your launch template uses a custom AMI, then don't specify amiType, or the node group deployment will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let amiType: AMITypes?
        /// The capacity type for your node group.
        public let capacityType: CapacityTypes?
        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the cluster to create the node group in.
        public let clusterName: String
        /// The root device disk size (in GiB) for your node group instances. The default disk size is 20 GiB. If you specify launchTemplate, then don't specify diskSize, or the node group deployment will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let diskSize: Int?
        /// Specify the instance types for a node group. If you specify a GPU instance type, be sure to specify AL2_x86_64_GPU with the amiType parameter. If you specify launchTemplate, then you can specify zero or one instance type in your launch template or you can specify 0-20 instance types for instanceTypes. If however, you specify an instance type in your launch template and specify any instanceTypes, the node group deployment will fail. If you don't specify an instance type in a launch template or for instanceTypes, then t3.medium is used, by default. If you specify Spot for capacityType, then we recommend specifying multiple values for instanceTypes. For more information, see Managed node group capacity types and Launch template support in the Amazon EKS User Guide.
        public let instanceTypes: [String]?
        /// The Kubernetes labels to be applied to the nodes in the node group when they are created.
        public let labels: [String: String]?
        /// An object representing a node group's launch template specification. If specified, then do not specify instanceTypes, diskSize, or remoteAccess and make sure that the launch template meets the requirements in launchTemplateSpecification.
        public let launchTemplate: LaunchTemplateSpecification?
        /// The unique name to give your node group.
        public let nodegroupName: String
        /// The Amazon Resource Name (ARN) of the IAM role to associate with your node group. The Amazon EKS worker node kubelet daemon makes calls to AWS APIs on your behalf. Nodes receive permissions for these API calls through an IAM instance profile and associated policies. Before you can launch nodes and register them into a cluster, you must create an IAM role for those nodes to use when they are launched. For more information, see Amazon EKS node IAM role in the  Amazon EKS User Guide . If you specify launchTemplate, then don't specify  IamInstanceProfile  in your launch template, or the node group deployment will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let nodeRole: String
        /// The AMI version of the Amazon EKS optimized AMI to use with your node group. By default, the latest available AMI version for the node group's current Kubernetes version is used. For more information, see Amazon EKS optimized Amazon Linux 2 AMI versions in the Amazon EKS User Guide. If you specify launchTemplate, and your launch template uses a custom AMI, then don't specify releaseVersion, or the node group deployment will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let releaseVersion: String?
        /// The remote access (SSH) configuration to use with your node group. If you specify launchTemplate, then don't specify remoteAccess, or the node group deployment will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let remoteAccess: RemoteAccessConfig?
        /// The scaling configuration details for the Auto Scaling group that is created for your node group.
        public let scalingConfig: NodegroupScalingConfig?
        /// The subnets to use for the Auto Scaling group that is created for your node group. These subnets must have the tag key kubernetes.io/cluster/CLUSTER_NAME with a value of shared, where CLUSTER_NAME is replaced with the name of your cluster. If you specify launchTemplate, then don't specify  SubnetId  in your launch template, or the node group deployment will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let subnets: [String]
        /// The metadata to apply to the node group to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define. Node group tags do not propagate to any other resources associated with the node group, such as the Amazon EC2 instances or subnets.
        public let tags: [String: String]?
        /// The Kubernetes version to use for your managed nodes. By default, the Kubernetes version of the cluster is used, and this is the only accepted specified value. If you specify launchTemplate, and your launch template uses a custom AMI, then don't specify version, or the node group deployment will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let version: String?

        public init(amiType: AMITypes? = nil, capacityType: CapacityTypes? = nil, clientRequestToken: String? = CreateNodegroupRequest.idempotencyToken(), clusterName: String, diskSize: Int? = nil, instanceTypes: [String]? = nil, labels: [String: String]? = nil, launchTemplate: LaunchTemplateSpecification? = nil, nodegroupName: String, nodeRole: String, releaseVersion: String? = nil, remoteAccess: RemoteAccessConfig? = nil, scalingConfig: NodegroupScalingConfig? = nil, subnets: [String], tags: [String: String]? = nil, version: String? = nil) {
            self.amiType = amiType
            self.capacityType = capacityType
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.diskSize = diskSize
            self.instanceTypes = instanceTypes
            self.labels = labels
            self.launchTemplate = launchTemplate
            self.nodegroupName = nodegroupName
            self.nodeRole = nodeRole
            self.releaseVersion = releaseVersion
            self.remoteAccess = remoteAccess
            self.scalingConfig = scalingConfig
            self.subnets = subnets
            self.tags = tags
            self.version = version
        }

        public func validate(name: String) throws {
            try self.labels?.forEach {
                try validate($0.key, name: "labels.key", parent: name, max: 63)
                try validate($0.key, name: "labels.key", parent: name, min: 1)
                try validate($0.value, name: "labels[\"\($0.key)\"]", parent: name, max: 253)
                try validate($0.value, name: "labels[\"\($0.key)\"]", parent: name, min: 1)
            }
            try self.scalingConfig?.validate(name: "\(name).scalingConfig")
            try self.tags?.forEach {
                try validate($0.key, name: "tags.key", parent: name, max: 128)
                try validate($0.key, name: "tags.key", parent: name, min: 1)
                try validate($0.value, name: "tags[\"\($0.key)\"]", parent: name, max: 256)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case amiType
            case capacityType
            case clientRequestToken
            case diskSize
            case instanceTypes
            case labels
            case launchTemplate
            case nodegroupName
            case nodeRole
            case releaseVersion
            case remoteAccess
            case scalingConfig
            case subnets
            case tags
            case version
        }
    }

    public struct CreateNodegroupResponse: AWSDecodableShape {
        /// The full description of your new node group.
        public let nodegroup: Nodegroup?

        public init(nodegroup: Nodegroup? = nil) {
            self.nodegroup = nodegroup
        }

        private enum CodingKeys: String, CodingKey {
            case nodegroup
        }
    }

    public struct DeleteAddonRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "addonName", location: .uri(locationName: "addonName")),
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// The name of the add-on. The name must match one of the names returned by  ListAddons .
        public let addonName: String
        /// The name of the cluster to delete the add-on from.
        public let clusterName: String

        public init(addonName: String, clusterName: String) {
            self.addonName = addonName
            self.clusterName = clusterName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterName, name: "clusterName", parent: name, max: 100)
            try self.validate(self.clusterName, name: "clusterName", parent: name, min: 1)
            try self.validate(self.clusterName, name: "clusterName", parent: name, pattern: "^[0-9A-Za-z][A-Za-z0-9\\-_]*")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteAddonResponse: AWSDecodableShape {
        public let addon: Addon?

        public init(addon: Addon? = nil) {
            self.addon = addon
        }

        private enum CodingKeys: String, CodingKey {
            case addon
        }
    }

    public struct DeleteClusterRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "name", location: .uri(locationName: "name"))
        ]

        /// The name of the cluster to delete.
        public let name: String

        public init(name: String) {
            self.name = name
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteClusterResponse: AWSDecodableShape {
        /// The full description of the cluster to delete.
        public let cluster: Cluster?

        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster
        }
    }

    public struct DeleteFargateProfileRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "fargateProfileName", location: .uri(locationName: "fargateProfileName"))
        ]

        /// The name of the Amazon EKS cluster associated with the Fargate profile to delete.
        public let clusterName: String
        /// The name of the Fargate profile to delete.
        public let fargateProfileName: String

        public init(clusterName: String, fargateProfileName: String) {
            self.clusterName = clusterName
            self.fargateProfileName = fargateProfileName
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteFargateProfileResponse: AWSDecodableShape {
        /// The deleted Fargate profile.
        public let fargateProfile: FargateProfile?

        public init(fargateProfile: FargateProfile? = nil) {
            self.fargateProfile = fargateProfile
        }

        private enum CodingKeys: String, CodingKey {
            case fargateProfile
        }
    }

    public struct DeleteNodegroupRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "nodegroupName", location: .uri(locationName: "nodegroupName"))
        ]

        /// The name of the Amazon EKS cluster that is associated with your node group.
        public let clusterName: String
        /// The name of the node group to delete.
        public let nodegroupName: String

        public init(clusterName: String, nodegroupName: String) {
            self.clusterName = clusterName
            self.nodegroupName = nodegroupName
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteNodegroupResponse: AWSDecodableShape {
        /// The full description of your deleted node group.
        public let nodegroup: Nodegroup?

        public init(nodegroup: Nodegroup? = nil) {
            self.nodegroup = nodegroup
        }

        private enum CodingKeys: String, CodingKey {
            case nodegroup
        }
    }

    public struct DescribeAddonRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "addonName", location: .uri(locationName: "addonName")),
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// The name of the add-on. The name must match one of the names returned by  ListAddons .
        public let addonName: String
        /// The name of the cluster.
        public let clusterName: String

        public init(addonName: String, clusterName: String) {
            self.addonName = addonName
            self.clusterName = clusterName
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterName, name: "clusterName", parent: name, max: 100)
            try self.validate(self.clusterName, name: "clusterName", parent: name, min: 1)
            try self.validate(self.clusterName, name: "clusterName", parent: name, pattern: "^[0-9A-Za-z][A-Za-z0-9\\-_]*")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DescribeAddonResponse: AWSDecodableShape {
        public let addon: Addon?

        public init(addon: Addon? = nil) {
            self.addon = addon
        }

        private enum CodingKeys: String, CodingKey {
            case addon
        }
    }

    public struct DescribeAddonVersionsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "addonName", location: .querystring(locationName: "addonName")),
            AWSMemberEncoding(label: "kubernetesVersion", location: .querystring(locationName: "kubernetesVersion")),
            AWSMemberEncoding(label: "maxResults", location: .querystring(locationName: "maxResults")),
            AWSMemberEncoding(label: "nextToken", location: .querystring(locationName: "nextToken"))
        ]

        /// The name of the add-on. The name must match one of the names returned by  ListAddons .
        public let addonName: String?
        /// The Kubernetes versions that the add-on can be used with.
        public let kubernetesVersion: String?
        /// The maximum number of results to return.
        public let maxResults: Int?
        /// The nextToken value returned from a previous paginated DescribeAddonVersionsRequest where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.  This token should be treated as an opaque identifier that is used only to retrieve the next items in a list and not for other programmatic purposes.
        public let nextToken: String?

        public init(addonName: String? = nil, kubernetesVersion: String? = nil, maxResults: Int? = nil, nextToken: String? = nil) {
            self.addonName = addonName
            self.kubernetesVersion = kubernetesVersion
            self.maxResults = maxResults
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DescribeAddonVersionsResponse: AWSDecodableShape {
        /// The list of available versions with Kubernetes version compatibility.
        public let addons: [AddonInfo]?
        /// The nextToken value returned from a previous paginated DescribeAddonVersionsResponse where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.  This token should be treated as an opaque identifier that is used only to retrieve the next items in a list and not for other programmatic purposes.
        public let nextToken: String?

        public init(addons: [AddonInfo]? = nil, nextToken: String? = nil) {
            self.addons = addons
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case addons
            case nextToken
        }
    }

    public struct DescribeClusterRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "name", location: .uri(locationName: "name"))
        ]

        /// The name of the cluster to describe.
        public let name: String

        public init(name: String) {
            self.name = name
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DescribeClusterResponse: AWSDecodableShape {
        /// The full description of your specified cluster.
        public let cluster: Cluster?

        public init(cluster: Cluster? = nil) {
            self.cluster = cluster
        }

        private enum CodingKeys: String, CodingKey {
            case cluster
        }
    }

    public struct DescribeFargateProfileRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "fargateProfileName", location: .uri(locationName: "fargateProfileName"))
        ]

        /// The name of the Amazon EKS cluster associated with the Fargate profile.
        public let clusterName: String
        /// The name of the Fargate profile to describe.
        public let fargateProfileName: String

        public init(clusterName: String, fargateProfileName: String) {
            self.clusterName = clusterName
            self.fargateProfileName = fargateProfileName
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DescribeFargateProfileResponse: AWSDecodableShape {
        /// The full description of your Fargate profile.
        public let fargateProfile: FargateProfile?

        public init(fargateProfile: FargateProfile? = nil) {
            self.fargateProfile = fargateProfile
        }

        private enum CodingKeys: String, CodingKey {
            case fargateProfile
        }
    }

    public struct DescribeIdentityProviderConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// The cluster name that the identity provider configuration is associated to.
        public let clusterName: String
        /// An object that represents an identity provider configuration.
        public let identityProviderConfig: IdentityProviderConfig

        public init(clusterName: String, identityProviderConfig: IdentityProviderConfig) {
            self.clusterName = clusterName
            self.identityProviderConfig = identityProviderConfig
        }

        private enum CodingKeys: String, CodingKey {
            case identityProviderConfig
        }
    }

    public struct DescribeIdentityProviderConfigResponse: AWSDecodableShape {
        /// The object that represents an OpenID Connect (OIDC) identity provider configuration.
        public let identityProviderConfig: IdentityProviderConfigResponse?

        public init(identityProviderConfig: IdentityProviderConfigResponse? = nil) {
            self.identityProviderConfig = identityProviderConfig
        }

        private enum CodingKeys: String, CodingKey {
            case identityProviderConfig
        }
    }

    public struct DescribeNodegroupRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "nodegroupName", location: .uri(locationName: "nodegroupName"))
        ]

        /// The name of the Amazon EKS cluster associated with the node group.
        public let clusterName: String
        /// The name of the node group to describe.
        public let nodegroupName: String

        public init(clusterName: String, nodegroupName: String) {
            self.clusterName = clusterName
            self.nodegroupName = nodegroupName
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DescribeNodegroupResponse: AWSDecodableShape {
        /// The full description of your node group.
        public let nodegroup: Nodegroup?

        public init(nodegroup: Nodegroup? = nil) {
            self.nodegroup = nodegroup
        }

        private enum CodingKeys: String, CodingKey {
            case nodegroup
        }
    }

    public struct DescribeUpdateRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "addonName", location: .querystring(locationName: "addonName")),
            AWSMemberEncoding(label: "name", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "nodegroupName", location: .querystring(locationName: "nodegroupName")),
            AWSMemberEncoding(label: "updateId", location: .uri(locationName: "updateId"))
        ]

        /// The name of the add-on. The name must match one of the names returned by  ListAddons .
        public let addonName: String?
        /// The name of the Amazon EKS cluster associated with the update.
        public let name: String
        /// The name of the Amazon EKS node group associated with the update.
        public let nodegroupName: String?
        /// The ID of the update to describe.
        public let updateId: String

        public init(addonName: String? = nil, name: String, nodegroupName: String? = nil, updateId: String) {
            self.addonName = addonName
            self.name = name
            self.nodegroupName = nodegroupName
            self.updateId = updateId
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DescribeUpdateResponse: AWSDecodableShape {
        /// The full description of the specified update.
        public let update: Update?

        public init(update: Update? = nil) {
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case update
        }
    }

    public struct DisassociateIdentityProviderConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// A unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the cluster to disassociate an identity provider from.
        public let clusterName: String
        /// An object that represents an identity provider configuration.
        public let identityProviderConfig: IdentityProviderConfig

        public init(clientRequestToken: String? = DisassociateIdentityProviderConfigRequest.idempotencyToken(), clusterName: String, identityProviderConfig: IdentityProviderConfig) {
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.identityProviderConfig = identityProviderConfig
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case identityProviderConfig
        }
    }

    public struct DisassociateIdentityProviderConfigResponse: AWSDecodableShape {
        public let update: Update?

        public init(update: Update? = nil) {
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case update
        }
    }

    public struct EncryptionConfig: AWSEncodableShape & AWSDecodableShape {
        /// AWS Key Management Service (AWS KMS) customer master key (CMK). Either the ARN or the alias can be used.
        public let provider: Provider?
        /// Specifies the resources to be encrypted. The only supported value is "secrets".
        public let resources: [String]?

        public init(provider: Provider? = nil, resources: [String]? = nil) {
            self.provider = provider
            self.resources = resources
        }

        private enum CodingKeys: String, CodingKey {
            case provider
            case resources
        }
    }

    public struct ErrorDetail: AWSDecodableShape {
        /// A brief description of the error.     SubnetNotFound: We couldn't find one of the subnets associated with the cluster.    SecurityGroupNotFound: We couldn't find one of the security groups associated with the cluster.    EniLimitReached: You have reached the elastic network interface limit for your account.    IpNotAvailable: A subnet associated with the cluster doesn't have any free IP addresses.    AccessDenied: You don't have permissions to perform the specified operation.    OperationNotPermitted: The service role associated with the cluster doesn't have the required access permissions for Amazon EKS.    VpcIdNotFound: We couldn't find the VPC associated with the cluster.
        public let errorCode: ErrorCode?
        /// A more complete description of the error.
        public let errorMessage: String?
        /// An optional field that contains the resource IDs associated with the error.
        public let resourceIds: [String]?

        public init(errorCode: ErrorCode? = nil, errorMessage: String? = nil, resourceIds: [String]? = nil) {
            self.errorCode = errorCode
            self.errorMessage = errorMessage
            self.resourceIds = resourceIds
        }

        private enum CodingKeys: String, CodingKey {
            case errorCode
            case errorMessage
            case resourceIds
        }
    }

    public struct FargateProfile: AWSDecodableShape {
        /// The name of the Amazon EKS cluster that the Fargate profile belongs to.
        public let clusterName: String?
        /// The Unix epoch timestamp in seconds for when the Fargate profile was created.
        public let createdAt: Date?
        /// The full Amazon Resource Name (ARN) of the Fargate profile.
        public let fargateProfileArn: String?
        /// The name of the Fargate profile.
        public let fargateProfileName: String?
        /// The Amazon Resource Name (ARN) of the pod execution role to use for pods that match the selectors in the Fargate profile. For more information, see Pod Execution Role in the Amazon EKS User Guide.
        public let podExecutionRoleArn: String?
        /// The selectors to match for pods to use this Fargate profile.
        public let selectors: [FargateProfileSelector]?
        /// The current status of the Fargate profile.
        public let status: FargateProfileStatus?
        /// The IDs of subnets to launch pods into.
        public let subnets: [String]?
        /// The metadata applied to the Fargate profile to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define. Fargate profile tags do not propagate to any other resources associated with the Fargate profile, such as the pods that are scheduled with it.
        public let tags: [String: String]?

        public init(clusterName: String? = nil, createdAt: Date? = nil, fargateProfileArn: String? = nil, fargateProfileName: String? = nil, podExecutionRoleArn: String? = nil, selectors: [FargateProfileSelector]? = nil, status: FargateProfileStatus? = nil, subnets: [String]? = nil, tags: [String: String]? = nil) {
            self.clusterName = clusterName
            self.createdAt = createdAt
            self.fargateProfileArn = fargateProfileArn
            self.fargateProfileName = fargateProfileName
            self.podExecutionRoleArn = podExecutionRoleArn
            self.selectors = selectors
            self.status = status
            self.subnets = subnets
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case clusterName
            case createdAt
            case fargateProfileArn
            case fargateProfileName
            case podExecutionRoleArn
            case selectors
            case status
            case subnets
            case tags
        }
    }

    public struct FargateProfileSelector: AWSEncodableShape & AWSDecodableShape {
        /// The Kubernetes labels that the selector should match. A pod must contain all of the labels that are specified in the selector for it to be considered a match.
        public let labels: [String: String]?
        /// The Kubernetes namespace that the selector should match.
        public let namespace: String?

        public init(labels: [String: String]? = nil, namespace: String? = nil) {
            self.labels = labels
            self.namespace = namespace
        }

        private enum CodingKeys: String, CodingKey {
            case labels
            case namespace
        }
    }

    public struct Identity: AWSDecodableShape {
        /// An object representing the OpenID Connect identity provider information.
        public let oidc: OIDC?

        public init(oidc: OIDC? = nil) {
            self.oidc = oidc
        }

        private enum CodingKeys: String, CodingKey {
            case oidc
        }
    }

    public struct IdentityProviderConfig: AWSEncodableShape & AWSDecodableShape {
        /// The name of the identity provider configuration.
        public let name: String
        /// The type of the identity provider configuration.
        public let type: String

        public init(name: String, type: String) {
            self.name = name
            self.type = type
        }

        private enum CodingKeys: String, CodingKey {
            case name
            case type
        }
    }

    public struct IdentityProviderConfigResponse: AWSDecodableShape {
        /// An object that represents an OpenID Connect (OIDC) identity provider configuration.
        public let oidc: OidcIdentityProviderConfig?

        public init(oidc: OidcIdentityProviderConfig? = nil) {
            self.oidc = oidc
        }

        private enum CodingKeys: String, CodingKey {
            case oidc
        }
    }

    public struct Issue: AWSDecodableShape {
        /// A brief description of the error.    AccessDenied: Amazon EKS or one or more of your managed nodes is failing to authenticate or authorize with your Kubernetes cluster API server.    AsgInstanceLaunchFailures: Your Auto Scaling group is experiencing failures while attempting to launch instances.    AutoScalingGroupNotFound: We couldn't find the Auto Scaling group associated with the managed node group. You may be able to recreate an Auto Scaling group with the same settings to recover.    ClusterUnreachable: Amazon EKS or one or more of your managed nodes is unable to to communicate with your Kubernetes cluster API server. This can happen if there are network disruptions or if API servers are timing out processing requests.     Ec2LaunchTemplateNotFound: We couldn't find the Amazon EC2 launch template for your managed node group. You may be able to recreate a launch template with the same settings to recover.    Ec2LaunchTemplateVersionMismatch: The Amazon EC2 launch template version for your managed node group does not match the version that Amazon EKS created. You may be able to revert to the version that Amazon EKS created to recover.    Ec2SecurityGroupDeletionFailure: We could not delete the remote access security group for your managed node group. Remove any dependencies from the security group.    Ec2SecurityGroupNotFound: We couldn't find the cluster security group for the cluster. You must recreate your cluster.    Ec2SubnetInvalidConfiguration: One or more Amazon EC2 subnets specified for a node group do not automatically assign public IP addresses to instances launched into it. If you want your instances to be assigned a public IP address, then you need to enable the auto-assign public IP address setting for the subnet. See Modifying the public IPv4 addressing attribute for your subnet in the Amazon VPC User Guide.    IamInstanceProfileNotFound: We couldn't find the IAM instance profile for your managed node group. You may be able to recreate an instance profile with the same settings to recover.    IamNodeRoleNotFound: We couldn't find the IAM role for your managed node group. You may be able to recreate an IAM role with the same settings to recover.    InstanceLimitExceeded: Your AWS account is unable to launch any more instances of the specified instance type. You may be able to request an Amazon EC2 instance limit increase to recover.    InsufficientFreeAddresses: One or more of the subnets associated with your managed node group does not have enough available IP addresses for new nodes.    InternalFailure: These errors are usually caused by an Amazon EKS server-side issue.    NodeCreationFailure: Your launched instances are unable to register with your Amazon EKS cluster. Common causes of this failure are insufficient node IAM role permissions or lack of outbound internet access for the nodes.
        public let code: NodegroupIssueCode?
        /// The error message associated with the issue.
        public let message: String?
        /// The AWS resources that are afflicted by this issue.
        public let resourceIds: [String]?

        public init(code: NodegroupIssueCode? = nil, message: String? = nil, resourceIds: [String]? = nil) {
            self.code = code
            self.message = message
            self.resourceIds = resourceIds
        }

        private enum CodingKeys: String, CodingKey {
            case code
            case message
            case resourceIds
        }
    }

    public struct KubernetesNetworkConfigRequest: AWSEncodableShape {
        /// The CIDR block to assign Kubernetes service IP addresses from. If you don't specify a block, Kubernetes assigns addresses from either the 10.100.0.0/16 or 172.20.0.0/16 CIDR blocks. We recommend that you specify a block that does not overlap with resources in other networks that are peered or connected to your VPC. The block must meet the following requirements:   Within one of the following private IP address blocks: 10.0.0.0/8, 172.16.0.0.0/12, or 192.168.0.0/16.   Doesn't overlap with any CIDR block assigned to the VPC that you selected for VPC.   Between /24 and /12.    You can only specify a custom CIDR block when you create a cluster and can't change this value once the cluster is created.
        public let serviceIpv4Cidr: String?

        public init(serviceIpv4Cidr: String? = nil) {
            self.serviceIpv4Cidr = serviceIpv4Cidr
        }

        private enum CodingKeys: String, CodingKey {
            case serviceIpv4Cidr
        }
    }

    public struct KubernetesNetworkConfigResponse: AWSDecodableShape {
        /// The CIDR block that Kubernetes service IP addresses are assigned from. If you didn't specify a CIDR block when you created the cluster, then Kubernetes assigns addresses from either the 10.100.0.0/16 or 172.20.0.0/16 CIDR blocks. If this was specified, then it was specified when the cluster was created and it cannot be changed.
        public let serviceIpv4Cidr: String?

        public init(serviceIpv4Cidr: String? = nil) {
            self.serviceIpv4Cidr = serviceIpv4Cidr
        }

        private enum CodingKeys: String, CodingKey {
            case serviceIpv4Cidr
        }
    }

    public struct LaunchTemplateSpecification: AWSEncodableShape & AWSDecodableShape {
        /// The ID of the launch template.
        public let id: String?
        /// The name of the launch template.
        public let name: String?
        /// The version of the launch template to use. If no version is specified, then the template's default version is used.
        public let version: String?

        public init(id: String? = nil, name: String? = nil, version: String? = nil) {
            self.id = id
            self.name = name
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case id
            case name
            case version
        }
    }

    public struct ListAddonsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "maxResults", location: .querystring(locationName: "maxResults")),
            AWSMemberEncoding(label: "nextToken", location: .querystring(locationName: "nextToken"))
        ]

        /// The name of the cluster.
        public let clusterName: String
        /// The maximum number of add-on results returned by ListAddonsRequest in paginated output. When you use this parameter, ListAddonsRequest returns only maxResults results in a single page along with a nextToken response element. You can see the remaining results of the initial request by sending another ListAddonsRequest request with the returned nextToken value. This value can be between 1 and 100. If you don't use this parameter, ListAddonsRequest returns up to 100 results and a nextToken value, if applicable.
        public let maxResults: Int?
        /// The nextToken value returned from a previous paginated ListAddonsRequest where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.  This token should be treated as an opaque identifier that is used only to retrieve the next items in a list and not for other programmatic purposes.
        public let nextToken: String?

        public init(clusterName: String, maxResults: Int? = nil, nextToken: String? = nil) {
            self.clusterName = clusterName
            self.maxResults = maxResults
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterName, name: "clusterName", parent: name, max: 100)
            try self.validate(self.clusterName, name: "clusterName", parent: name, min: 1)
            try self.validate(self.clusterName, name: "clusterName", parent: name, pattern: "^[0-9A-Za-z][A-Za-z0-9\\-_]*")
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListAddonsResponse: AWSDecodableShape {
        /// A list of available add-ons.
        public let addons: [String]?
        /// The nextToken value returned from a previous paginated ListAddonsResponse where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.  This token should be treated as an opaque identifier that is used only to retrieve the next items in a list and not for other programmatic purposes.
        public let nextToken: String?

        public init(addons: [String]? = nil, nextToken: String? = nil) {
            self.addons = addons
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case addons
            case nextToken
        }
    }

    public struct ListClustersRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "maxResults", location: .querystring(locationName: "maxResults")),
            AWSMemberEncoding(label: "nextToken", location: .querystring(locationName: "nextToken"))
        ]

        /// The maximum number of cluster results returned by ListClusters in paginated output. When you use this parameter, ListClusters returns only maxResults results in a single page along with a nextToken response element. You can see the remaining results of the initial request by sending another ListClusters request with the returned nextToken value. This value can be between 1 and 100. If you don't use this parameter, ListClusters returns up to 100 results and a nextToken value if applicable.
        public let maxResults: Int?
        /// The nextToken value returned from a previous paginated ListClusters request where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.  This token should be treated as an opaque identifier that is used only to retrieve the next items in a list and not for other programmatic purposes.
        public let nextToken: String?

        public init(maxResults: Int? = nil, nextToken: String? = nil) {
            self.maxResults = maxResults
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListClustersResponse: AWSDecodableShape {
        /// A list of all of the clusters for your account in the specified Region.
        public let clusters: [String]?
        /// The nextToken value to include in a future ListClusters request. When the results of a ListClusters request exceed maxResults, you can use this value to retrieve the next page of results. This value is null when there are no more results to return.
        public let nextToken: String?

        public init(clusters: [String]? = nil, nextToken: String? = nil) {
            self.clusters = clusters
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case clusters
            case nextToken
        }
    }

    public struct ListFargateProfilesRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "maxResults", location: .querystring(locationName: "maxResults")),
            AWSMemberEncoding(label: "nextToken", location: .querystring(locationName: "nextToken"))
        ]

        /// The name of the Amazon EKS cluster that you would like to listFargate profiles in.
        public let clusterName: String
        /// The maximum number of Fargate profile results returned by ListFargateProfiles in paginated output. When you use this parameter, ListFargateProfiles returns only maxResults results in a single page along with a nextToken response element. You can see the remaining results of the initial request by sending another ListFargateProfiles request with the returned nextToken value. This value can be between 1 and 100. If you don't use this parameter, ListFargateProfiles returns up to 100 results and a nextToken value if applicable.
        public let maxResults: Int?
        /// The nextToken value returned from a previous paginated ListFargateProfiles request where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.
        public let nextToken: String?

        public init(clusterName: String, maxResults: Int? = nil, nextToken: String? = nil) {
            self.clusterName = clusterName
            self.maxResults = maxResults
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListFargateProfilesResponse: AWSDecodableShape {
        /// A list of all of the Fargate profiles associated with the specified cluster.
        public let fargateProfileNames: [String]?
        /// The nextToken value to include in a future ListFargateProfiles request. When the results of a ListFargateProfiles request exceed maxResults, you can use this value to retrieve the next page of results. This value is null when there are no more results to return.
        public let nextToken: String?

        public init(fargateProfileNames: [String]? = nil, nextToken: String? = nil) {
            self.fargateProfileNames = fargateProfileNames
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case fargateProfileNames
            case nextToken
        }
    }

    public struct ListIdentityProviderConfigsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "maxResults", location: .querystring(locationName: "maxResults")),
            AWSMemberEncoding(label: "nextToken", location: .querystring(locationName: "nextToken"))
        ]

        /// The cluster name that you want to list identity provider configurations for.
        public let clusterName: String
        /// The maximum number of identity provider configurations returned by ListIdentityProviderConfigs in paginated output. When you use this parameter, ListIdentityProviderConfigs returns only maxResults results in a single page along with a nextToken response element. You can see the remaining results of the initial request by sending another ListIdentityProviderConfigs request with the returned nextToken value. This value can be between 1 and 100. If you don't use this parameter, ListIdentityProviderConfigs returns up to 100 results and a nextToken value, if applicable.
        public let maxResults: Int?
        /// The nextToken value returned from a previous paginated IdentityProviderConfigsRequest where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.
        public let nextToken: String?

        public init(clusterName: String, maxResults: Int? = nil, nextToken: String? = nil) {
            self.clusterName = clusterName
            self.maxResults = maxResults
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListIdentityProviderConfigsResponse: AWSDecodableShape {
        /// The identity provider configurations for the cluster.
        public let identityProviderConfigs: [IdentityProviderConfig]?
        /// The nextToken value returned from a previous paginated ListIdentityProviderConfigsResponse where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.
        public let nextToken: String?

        public init(identityProviderConfigs: [IdentityProviderConfig]? = nil, nextToken: String? = nil) {
            self.identityProviderConfigs = identityProviderConfigs
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case identityProviderConfigs
            case nextToken
        }
    }

    public struct ListNodegroupsRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "maxResults", location: .querystring(locationName: "maxResults")),
            AWSMemberEncoding(label: "nextToken", location: .querystring(locationName: "nextToken"))
        ]

        /// The name of the Amazon EKS cluster that you would like to list node groups in.
        public let clusterName: String
        /// The maximum number of node group results returned by ListNodegroups in paginated output. When you use this parameter, ListNodegroups returns only maxResults results in a single page along with a nextToken response element. You can see the remaining results of the initial request by sending another ListNodegroups request with the returned nextToken value. This value can be between 1 and 100. If you don't use this parameter, ListNodegroups returns up to 100 results and a nextToken value if applicable.
        public let maxResults: Int?
        /// The nextToken value returned from a previous paginated ListNodegroups request where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.
        public let nextToken: String?

        public init(clusterName: String, maxResults: Int? = nil, nextToken: String? = nil) {
            self.clusterName = clusterName
            self.maxResults = maxResults
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListNodegroupsResponse: AWSDecodableShape {
        /// The nextToken value to include in a future ListNodegroups request. When the results of a ListNodegroups request exceed maxResults, you can use this value to retrieve the next page of results. This value is null when there are no more results to return.
        public let nextToken: String?
        /// A list of all of the node groups associated with the specified cluster.
        public let nodegroups: [String]?

        public init(nextToken: String? = nil, nodegroups: [String]? = nil) {
            self.nextToken = nextToken
            self.nodegroups = nodegroups
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken
            case nodegroups
        }
    }

    public struct ListTagsForResourceRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "resourceArn", location: .uri(locationName: "resourceArn"))
        ]

        /// The Amazon Resource Name (ARN) that identifies the resource for which to list the tags. Currently, the supported resources are Amazon EKS clusters and managed node groups.
        public let resourceArn: String

        public init(resourceArn: String) {
            self.resourceArn = resourceArn
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListTagsForResourceResponse: AWSDecodableShape {
        /// The tags for the resource.
        public let tags: [String: String]?

        public init(tags: [String: String]? = nil) {
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case tags
        }
    }

    public struct ListUpdatesRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "addonName", location: .querystring(locationName: "addonName")),
            AWSMemberEncoding(label: "maxResults", location: .querystring(locationName: "maxResults")),
            AWSMemberEncoding(label: "name", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "nextToken", location: .querystring(locationName: "nextToken")),
            AWSMemberEncoding(label: "nodegroupName", location: .querystring(locationName: "nodegroupName"))
        ]

        /// The names of the installed add-ons that have available updates.
        public let addonName: String?
        /// The maximum number of update results returned by ListUpdates in paginated output. When you use this parameter, ListUpdates returns only maxResults results in a single page along with a nextToken response element. You can see the remaining results of the initial request by sending another ListUpdates request with the returned nextToken value. This value can be between 1 and 100. If you don't use this parameter, ListUpdates returns up to 100 results and a nextToken value if applicable.
        public let maxResults: Int?
        /// The name of the Amazon EKS cluster to list updates for.
        public let name: String
        /// The nextToken value returned from a previous paginated ListUpdates request where maxResults was used and the results exceeded the value of that parameter. Pagination continues from the end of the previous results that returned the nextToken value.
        public let nextToken: String?
        /// The name of the Amazon EKS managed node group to list updates for.
        public let nodegroupName: String?

        public init(addonName: String? = nil, maxResults: Int? = nil, name: String, nextToken: String? = nil, nodegroupName: String? = nil) {
            self.addonName = addonName
            self.maxResults = maxResults
            self.name = name
            self.nextToken = nextToken
            self.nodegroupName = nodegroupName
        }

        public func validate(name: String) throws {
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 100)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListUpdatesResponse: AWSDecodableShape {
        /// The nextToken value to include in a future ListUpdates request. When the results of a ListUpdates request exceed maxResults, you can use this value to retrieve the next page of results. This value is null when there are no more results to return.
        public let nextToken: String?
        /// A list of all the updates for the specified cluster and Region.
        public let updateIds: [String]?

        public init(nextToken: String? = nil, updateIds: [String]? = nil) {
            self.nextToken = nextToken
            self.updateIds = updateIds
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken
            case updateIds
        }
    }

    public struct LogSetup: AWSEncodableShape & AWSDecodableShape {
        /// If a log type is enabled, that log type exports its control plane logs to CloudWatch Logs. If a log type isn't enabled, that log type doesn't export its control plane logs. Each individual log type can be enabled or disabled independently.
        public let enabled: Bool?
        /// The available cluster control plane log types.
        public let types: [LogType]?

        public init(enabled: Bool? = nil, types: [LogType]? = nil) {
            self.enabled = enabled
            self.types = types
        }

        private enum CodingKeys: String, CodingKey {
            case enabled
            case types
        }
    }

    public struct Logging: AWSEncodableShape & AWSDecodableShape {
        /// The cluster control plane logging configuration for your cluster.
        public let clusterLogging: [LogSetup]?

        public init(clusterLogging: [LogSetup]? = nil) {
            self.clusterLogging = clusterLogging
        }

        private enum CodingKeys: String, CodingKey {
            case clusterLogging
        }
    }

    public struct Nodegroup: AWSDecodableShape {
        /// If the node group was deployed using a launch template with a custom AMI, then this is CUSTOM. For node groups that weren't deployed using a launch template, this is the AMI type that was specified in the node group configuration.
        public let amiType: AMITypes?
        /// The capacity type of your managed node group.
        public let capacityType: CapacityTypes?
        /// The name of the cluster that the managed node group resides in.
        public let clusterName: String?
        /// The Unix epoch timestamp in seconds for when the managed node group was created.
        public let createdAt: Date?
        /// If the node group wasn't deployed with a launch template, then this is the disk size in the node group configuration. If the node group was deployed with a launch template, then this is null.
        public let diskSize: Int?
        /// The health status of the node group. If there are issues with your node group's health, they are listed here.
        public let health: NodegroupHealth?
        /// If the node group wasn't deployed with a launch template, then this is the instance type that is associated with the node group. If the node group was deployed with a launch template, then this is null.
        public let instanceTypes: [String]?
        /// The Kubernetes labels applied to the nodes in the node group.  Only labels that are applied with the Amazon EKS API are shown here. There may be other Kubernetes labels applied to the nodes in this group.
        public let labels: [String: String]?
        /// If a launch template was used to create the node group, then this is the launch template that was used.
        public let launchTemplate: LaunchTemplateSpecification?
        /// The Unix epoch timestamp in seconds for when the managed node group was last modified.
        public let modifiedAt: Date?
        /// The Amazon Resource Name (ARN) associated with the managed node group.
        public let nodegroupArn: String?
        /// The name associated with an Amazon EKS managed node group.
        public let nodegroupName: String?
        /// The IAM role associated with your node group. The Amazon EKS node kubelet daemon makes calls to AWS APIs on your behalf. Nodes receive permissions for these API calls through an IAM instance profile and associated policies.
        public let nodeRole: String?
        /// If the node group was deployed using a launch template with a custom AMI, then this is the AMI ID that was specified in the launch template. For node groups that weren't deployed using a launch template, this is the version of the Amazon EKS optimized AMI that the node group was deployed with.
        public let releaseVersion: String?
        /// If the node group wasn't deployed with a launch template, then this is the remote access configuration that is associated with the node group. If the node group was deployed with a launch template, then this is null.
        public let remoteAccess: RemoteAccessConfig?
        /// The resources associated with the node group, such as Auto Scaling groups and security groups for remote access.
        public let resources: NodegroupResources?
        /// The scaling configuration details for the Auto Scaling group that is associated with your node group.
        public let scalingConfig: NodegroupScalingConfig?
        /// The current status of the managed node group.
        public let status: NodegroupStatus?
        /// The subnets that were specified for the Auto Scaling group that is associated with your node group.
        public let subnets: [String]?
        /// The metadata applied to the node group to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you define. Node group tags do not propagate to any other resources associated with the node group, such as the Amazon EC2 instances or subnets.
        public let tags: [String: String]?
        /// The Kubernetes version of the managed node group.
        public let version: String?

        public init(amiType: AMITypes? = nil, capacityType: CapacityTypes? = nil, clusterName: String? = nil, createdAt: Date? = nil, diskSize: Int? = nil, health: NodegroupHealth? = nil, instanceTypes: [String]? = nil, labels: [String: String]? = nil, launchTemplate: LaunchTemplateSpecification? = nil, modifiedAt: Date? = nil, nodegroupArn: String? = nil, nodegroupName: String? = nil, nodeRole: String? = nil, releaseVersion: String? = nil, remoteAccess: RemoteAccessConfig? = nil, resources: NodegroupResources? = nil, scalingConfig: NodegroupScalingConfig? = nil, status: NodegroupStatus? = nil, subnets: [String]? = nil, tags: [String: String]? = nil, version: String? = nil) {
            self.amiType = amiType
            self.capacityType = capacityType
            self.clusterName = clusterName
            self.createdAt = createdAt
            self.diskSize = diskSize
            self.health = health
            self.instanceTypes = instanceTypes
            self.labels = labels
            self.launchTemplate = launchTemplate
            self.modifiedAt = modifiedAt
            self.nodegroupArn = nodegroupArn
            self.nodegroupName = nodegroupName
            self.nodeRole = nodeRole
            self.releaseVersion = releaseVersion
            self.remoteAccess = remoteAccess
            self.resources = resources
            self.scalingConfig = scalingConfig
            self.status = status
            self.subnets = subnets
            self.tags = tags
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case amiType
            case capacityType
            case clusterName
            case createdAt
            case diskSize
            case health
            case instanceTypes
            case labels
            case launchTemplate
            case modifiedAt
            case nodegroupArn
            case nodegroupName
            case nodeRole
            case releaseVersion
            case remoteAccess
            case resources
            case scalingConfig
            case status
            case subnets
            case tags
            case version
        }
    }

    public struct NodegroupHealth: AWSDecodableShape {
        /// Any issues that are associated with the node group.
        public let issues: [Issue]?

        public init(issues: [Issue]? = nil) {
            self.issues = issues
        }

        private enum CodingKeys: String, CodingKey {
            case issues
        }
    }

    public struct NodegroupResources: AWSDecodableShape {
        /// The Auto Scaling groups associated with the node group.
        public let autoScalingGroups: [AutoScalingGroup]?
        /// The remote access security group associated with the node group. This security group controls SSH access to the nodes.
        public let remoteAccessSecurityGroup: String?

        public init(autoScalingGroups: [AutoScalingGroup]? = nil, remoteAccessSecurityGroup: String? = nil) {
            self.autoScalingGroups = autoScalingGroups
            self.remoteAccessSecurityGroup = remoteAccessSecurityGroup
        }

        private enum CodingKeys: String, CodingKey {
            case autoScalingGroups
            case remoteAccessSecurityGroup
        }
    }

    public struct NodegroupScalingConfig: AWSEncodableShape & AWSDecodableShape {
        /// The current number of nodes that the managed node group should maintain.
        public let desiredSize: Int?
        /// The maximum number of nodes that the managed node group can scale out to. For information about the maximum number that you can specify, see Amazon EKS service quotas in the Amazon EKS User Guide.
        public let maxSize: Int?
        /// The minimum number of nodes that the managed node group can scale in to. This number must be greater than zero.
        public let minSize: Int?

        public init(desiredSize: Int? = nil, maxSize: Int? = nil, minSize: Int? = nil) {
            self.desiredSize = desiredSize
            self.maxSize = maxSize
            self.minSize = minSize
        }

        public func validate(name: String) throws {
            try self.validate(self.desiredSize, name: "desiredSize", parent: name, min: 1)
            try self.validate(self.maxSize, name: "maxSize", parent: name, min: 1)
            try self.validate(self.minSize, name: "minSize", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case desiredSize
            case maxSize
            case minSize
        }
    }

    public struct OIDC: AWSDecodableShape {
        /// The issuer URL for the OIDC identity provider.
        public let issuer: String?

        public init(issuer: String? = nil) {
            self.issuer = issuer
        }

        private enum CodingKeys: String, CodingKey {
            case issuer
        }
    }

    public struct OidcIdentityProviderConfig: AWSDecodableShape {
        /// This is also known as audience. The ID of the client application that makes authentication requests to the OIDC identity provider.
        public let clientId: String?
        /// The cluster that the configuration is associated to.
        public let clusterName: String?
        /// The JSON web token (JWT) claim that the provider uses to return your groups.
        public let groupsClaim: String?
        /// The prefix that is prepended to group claims to prevent clashes with existing names (such as system: groups). For example, the value oidc: creates group names like oidc:engineering and oidc:infra. The prefix can't contain system:
        public let groupsPrefix: String?
        /// The ARN of the configuration.
        public let identityProviderConfigArn: String?
        /// The name of the configuration.
        public let identityProviderConfigName: String?
        /// The URL of the OIDC identity provider that allows the API server to discover public signing keys for verifying tokens.
        public let issuerUrl: String?
        /// The key-value pairs that describe required claims in the identity token. If set, each claim is verified to be present in the token with a matching value.
        public let requiredClaims: [String: String]?
        /// The status of the OIDC identity provider.
        public let status: ConfigStatus?
        /// The metadata to apply to the provider configuration to assist with categorization and organization. Each tag consists of a key and an optional value, both of which you defined.
        public let tags: [String: String]?
        /// The JSON Web token (JWT) claim that is used as the username.
        public let usernameClaim: String?
        /// The prefix that is prepended to username claims to prevent clashes with existing names. The prefix can't contain system:
        public let usernamePrefix: String?

        public init(clientId: String? = nil, clusterName: String? = nil, groupsClaim: String? = nil, groupsPrefix: String? = nil, identityProviderConfigArn: String? = nil, identityProviderConfigName: String? = nil, issuerUrl: String? = nil, requiredClaims: [String: String]? = nil, status: ConfigStatus? = nil, tags: [String: String]? = nil, usernameClaim: String? = nil, usernamePrefix: String? = nil) {
            self.clientId = clientId
            self.clusterName = clusterName
            self.groupsClaim = groupsClaim
            self.groupsPrefix = groupsPrefix
            self.identityProviderConfigArn = identityProviderConfigArn
            self.identityProviderConfigName = identityProviderConfigName
            self.issuerUrl = issuerUrl
            self.requiredClaims = requiredClaims
            self.status = status
            self.tags = tags
            self.usernameClaim = usernameClaim
            self.usernamePrefix = usernamePrefix
        }

        private enum CodingKeys: String, CodingKey {
            case clientId
            case clusterName
            case groupsClaim
            case groupsPrefix
            case identityProviderConfigArn
            case identityProviderConfigName
            case issuerUrl
            case requiredClaims
            case status
            case tags
            case usernameClaim
            case usernamePrefix
        }
    }

    public struct OidcIdentityProviderConfigRequest: AWSEncodableShape {
        /// This is also known as audience. The ID for the client application that makes authentication requests to the OpenID identity provider.
        public let clientId: String
        /// The JWT claim that the provider uses to return your groups.
        public let groupsClaim: String?
        /// The prefix that is prepended to group claims to prevent clashes with existing names (such as system: groups). For example, the value oidc: will create group names like oidc:engineering and oidc:infra.
        public let groupsPrefix: String?
        /// The name of the OIDC provider configuration.
        public let identityProviderConfigName: String
        /// The URL of the OpenID identity provider that allows the API server to discover public signing keys for verifying tokens. The URL must begin with https:// and should correspond to the iss claim in the provider's OIDC ID tokens. Per the OIDC standard, path components are allowed but query parameters are not. Typically the URL consists of only a hostname, like https://server.example.org or https://example.com. This URL should point to the level below .well-known/openid-configuration and must be publicly accessible over the internet.
        public let issuerUrl: String
        /// The key value pairs that describe required claims in the identity token. If set, each claim is verified to be present in the token with a matching value. For the maximum number of claims that you can require, see Amazon EKS service quotas in the Amazon EKS User Guide.
        public let requiredClaims: [String: String]?
        /// The JSON Web Token (JWT) claim to use as the username. The default is sub, which is expected to be a unique identifier of the end user. You can choose other claims, such as email or name, depending on the OpenID identity provider. Claims other than email are prefixed with the issuer URL to prevent naming clashes with other plug-ins.
        public let usernameClaim: String?
        /// The prefix that is prepended to username claims to prevent clashes with existing names. If you do not provide this field, and username is a value other than email, the prefix defaults to issuerurl#. You can use the value - to disable all prefixing.
        public let usernamePrefix: String?

        public init(clientId: String, groupsClaim: String? = nil, groupsPrefix: String? = nil, identityProviderConfigName: String, issuerUrl: String, requiredClaims: [String: String]? = nil, usernameClaim: String? = nil, usernamePrefix: String? = nil) {
            self.clientId = clientId
            self.groupsClaim = groupsClaim
            self.groupsPrefix = groupsPrefix
            self.identityProviderConfigName = identityProviderConfigName
            self.issuerUrl = issuerUrl
            self.requiredClaims = requiredClaims
            self.usernameClaim = usernameClaim
            self.usernamePrefix = usernamePrefix
        }

        public func validate(name: String) throws {
            try self.requiredClaims?.forEach {
                try validate($0.key, name: "requiredClaims.key", parent: name, max: 63)
                try validate($0.key, name: "requiredClaims.key", parent: name, min: 1)
                try validate($0.value, name: "requiredClaims[\"\($0.key)\"]", parent: name, max: 253)
                try validate($0.value, name: "requiredClaims[\"\($0.key)\"]", parent: name, min: 1)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case clientId
            case groupsClaim
            case groupsPrefix
            case identityProviderConfigName
            case issuerUrl
            case requiredClaims
            case usernameClaim
            case usernamePrefix
        }
    }

    public struct Provider: AWSEncodableShape & AWSDecodableShape {
        /// Amazon Resource Name (ARN) or alias of the customer master key (CMK). The CMK must be symmetric, created in the same region as the cluster, and if the CMK was created in a different account, the user must have access to the CMK. For more information, see Allowing Users in Other Accounts to Use a CMK in the AWS Key Management Service Developer Guide.
        public let keyArn: String?

        public init(keyArn: String? = nil) {
            self.keyArn = keyArn
        }

        private enum CodingKeys: String, CodingKey {
            case keyArn
        }
    }

    public struct RemoteAccessConfig: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon EC2 SSH key that provides access for SSH communication with the nodes in the managed node group. For more information, see Amazon EC2 Key Pairs in the Amazon Elastic Compute Cloud User Guide for Linux Instances.
        public let ec2SshKey: String?
        /// The security groups that are allowed SSH access (port 22) to the nodes. If you specify an Amazon EC2 SSH key but do not specify a source security group when you create a managed node group, then port 22 on the nodes is opened to the internet (0.0.0.0/0). For more information, see Security Groups for Your VPC in the Amazon Virtual Private Cloud User Guide.
        public let sourceSecurityGroups: [String]?

        public init(ec2SshKey: String? = nil, sourceSecurityGroups: [String]? = nil) {
            self.ec2SshKey = ec2SshKey
            self.sourceSecurityGroups = sourceSecurityGroups
        }

        private enum CodingKeys: String, CodingKey {
            case ec2SshKey
            case sourceSecurityGroups
        }
    }

    public struct TagResourceRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "resourceArn", location: .uri(locationName: "resourceArn"))
        ]

        /// The Amazon Resource Name (ARN) of the resource to which to add tags. Currently, the supported resources are Amazon EKS clusters and managed node groups.
        public let resourceArn: String
        /// The tags to add to the resource. A tag is an array of key-value pairs.
        public let tags: [String: String]

        public init(resourceArn: String, tags: [String: String]) {
            self.resourceArn = resourceArn
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.tags.forEach {
                try validate($0.key, name: "tags.key", parent: name, max: 128)
                try validate($0.key, name: "tags.key", parent: name, min: 1)
                try validate($0.value, name: "tags[\"\($0.key)\"]", parent: name, max: 256)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case tags
        }
    }

    public struct TagResourceResponse: AWSDecodableShape {
        public init() {}
    }

    public struct UntagResourceRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "resourceArn", location: .uri(locationName: "resourceArn")),
            AWSMemberEncoding(label: "tagKeys", location: .querystring(locationName: "tagKeys"))
        ]

        /// The Amazon Resource Name (ARN) of the resource from which to delete tags. Currently, the supported resources are Amazon EKS clusters and managed node groups.
        public let resourceArn: String
        /// The keys of the tags to be removed.
        public let tagKeys: [String]

        public init(resourceArn: String, tagKeys: [String]) {
            self.resourceArn = resourceArn
            self.tagKeys = tagKeys
        }

        public func validate(name: String) throws {
            try self.tagKeys.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 128)
                try validate($0, name: "tagKeys[]", parent: name, min: 1)
            }
            try self.validate(self.tagKeys, name: "tagKeys", parent: name, max: 50)
            try self.validate(self.tagKeys, name: "tagKeys", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct UntagResourceResponse: AWSDecodableShape {
        public init() {}
    }

    public struct Update: AWSDecodableShape {
        /// The Unix epoch timestamp in seconds for when the update was created.
        public let createdAt: Date?
        /// Any errors associated with a Failed update.
        public let errors: [ErrorDetail]?
        /// A UUID that is used to track the update.
        public let id: String?
        /// A key-value map that contains the parameters associated with the update.
        public let params: [UpdateParam]?
        /// The current status of the update.
        public let status: UpdateStatus?
        /// The type of the update.
        public let type: UpdateType?

        public init(createdAt: Date? = nil, errors: [ErrorDetail]? = nil, id: String? = nil, params: [UpdateParam]? = nil, status: UpdateStatus? = nil, type: UpdateType? = nil) {
            self.createdAt = createdAt
            self.errors = errors
            self.id = id
            self.params = params
            self.status = status
            self.type = type
        }

        private enum CodingKeys: String, CodingKey {
            case createdAt
            case errors
            case id
            case params
            case status
            case type
        }
    }

    public struct UpdateAddonRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "addonName", location: .uri(locationName: "addonName")),
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name"))
        ]

        /// The name of the add-on. The name must match one of the names returned by  ListAddons .
        public let addonName: String
        /// The version of the add-on. The version must match one of the versions returned by  DescribeAddonVersions .
        public let addonVersion: String?
        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the cluster.
        public let clusterName: String
        /// How to resolve parameter value conflicts when applying the new version of the add-on to the cluster.
        public let resolveConflicts: ResolveConflicts?
        /// The Amazon Resource Name (ARN) of an existing IAM role to bind to the add-on's service account. The role must be assigned the IAM permissions required by the add-on. If you don't specify an existing IAM role, then the add-on uses the permissions assigned to the node IAM role. For more information, see Amazon EKS node IAM role in the Amazon EKS User Guide.  To specify an existing IAM role, you must have an IAM OpenID Connect (OIDC) provider created for your cluster. For more information, see Enabling IAM roles for service accounts on your cluster in the Amazon EKS User Guide.
        public let serviceAccountRoleArn: String?

        public init(addonName: String, addonVersion: String? = nil, clientRequestToken: String? = UpdateAddonRequest.idempotencyToken(), clusterName: String, resolveConflicts: ResolveConflicts? = nil, serviceAccountRoleArn: String? = nil) {
            self.addonName = addonName
            self.addonVersion = addonVersion
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.resolveConflicts = resolveConflicts
            self.serviceAccountRoleArn = serviceAccountRoleArn
        }

        public func validate(name: String) throws {
            try self.validate(self.clusterName, name: "clusterName", parent: name, max: 100)
            try self.validate(self.clusterName, name: "clusterName", parent: name, min: 1)
            try self.validate(self.clusterName, name: "clusterName", parent: name, pattern: "^[0-9A-Za-z][A-Za-z0-9\\-_]*")
            try self.validate(self.serviceAccountRoleArn, name: "serviceAccountRoleArn", parent: name, max: 255)
            try self.validate(self.serviceAccountRoleArn, name: "serviceAccountRoleArn", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case addonVersion
            case clientRequestToken
            case resolveConflicts
            case serviceAccountRoleArn
        }
    }

    public struct UpdateAddonResponse: AWSDecodableShape {
        public let update: Update?

        public init(update: Update? = nil) {
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case update
        }
    }

    public struct UpdateClusterConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "name", location: .uri(locationName: "name"))
        ]

        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// Enable or disable exporting the Kubernetes control plane logs for your cluster to CloudWatch Logs. By default, cluster control plane logs aren't exported to CloudWatch Logs. For more information, see Amazon EKS Cluster Control Plane Logs in the  Amazon EKS User Guide .  CloudWatch Logs ingestion, archive storage, and data scanning rates apply to exported control plane logs. For more information, see Amazon CloudWatch Pricing.
        public let logging: Logging?
        /// The name of the Amazon EKS cluster to update.
        public let name: String
        public let resourcesVpcConfig: VpcConfigRequest?

        public init(clientRequestToken: String? = UpdateClusterConfigRequest.idempotencyToken(), logging: Logging? = nil, name: String, resourcesVpcConfig: VpcConfigRequest? = nil) {
            self.clientRequestToken = clientRequestToken
            self.logging = logging
            self.name = name
            self.resourcesVpcConfig = resourcesVpcConfig
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case logging
            case resourcesVpcConfig
        }
    }

    public struct UpdateClusterConfigResponse: AWSDecodableShape {
        public let update: Update?

        public init(update: Update? = nil) {
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case update
        }
    }

    public struct UpdateClusterVersionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "name", location: .uri(locationName: "name"))
        ]

        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the Amazon EKS cluster to update.
        public let name: String
        /// The desired Kubernetes version following a successful update.
        public let version: String

        public init(clientRequestToken: String? = UpdateClusterVersionRequest.idempotencyToken(), name: String, version: String) {
            self.clientRequestToken = clientRequestToken
            self.name = name
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case version
        }
    }

    public struct UpdateClusterVersionResponse: AWSDecodableShape {
        /// The full description of the specified update
        public let update: Update?

        public init(update: Update? = nil) {
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case update
        }
    }

    public struct UpdateLabelsPayload: AWSEncodableShape {
        /// Kubernetes labels to be added or updated.
        public let addOrUpdateLabels: [String: String]?
        /// Kubernetes labels to be removed.
        public let removeLabels: [String]?

        public init(addOrUpdateLabels: [String: String]? = nil, removeLabels: [String]? = nil) {
            self.addOrUpdateLabels = addOrUpdateLabels
            self.removeLabels = removeLabels
        }

        public func validate(name: String) throws {
            try self.addOrUpdateLabels?.forEach {
                try validate($0.key, name: "addOrUpdateLabels.key", parent: name, max: 63)
                try validate($0.key, name: "addOrUpdateLabels.key", parent: name, min: 1)
                try validate($0.value, name: "addOrUpdateLabels[\"\($0.key)\"]", parent: name, max: 253)
                try validate($0.value, name: "addOrUpdateLabels[\"\($0.key)\"]", parent: name, min: 1)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case addOrUpdateLabels
            case removeLabels
        }
    }

    public struct UpdateNodegroupConfigRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "nodegroupName", location: .uri(locationName: "nodegroupName"))
        ]

        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the Amazon EKS cluster that the managed node group resides in.
        public let clusterName: String
        /// The Kubernetes labels to be applied to the nodes in the node group after the update.
        public let labels: UpdateLabelsPayload?
        /// The name of the managed node group to update.
        public let nodegroupName: String
        /// The scaling configuration details for the Auto Scaling group after the update.
        public let scalingConfig: NodegroupScalingConfig?

        public init(clientRequestToken: String? = UpdateNodegroupConfigRequest.idempotencyToken(), clusterName: String, labels: UpdateLabelsPayload? = nil, nodegroupName: String, scalingConfig: NodegroupScalingConfig? = nil) {
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.labels = labels
            self.nodegroupName = nodegroupName
            self.scalingConfig = scalingConfig
        }

        public func validate(name: String) throws {
            try self.labels?.validate(name: "\(name).labels")
            try self.scalingConfig?.validate(name: "\(name).scalingConfig")
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case labels
            case scalingConfig
        }
    }

    public struct UpdateNodegroupConfigResponse: AWSDecodableShape {
        public let update: Update?

        public init(update: Update? = nil) {
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case update
        }
    }

    public struct UpdateNodegroupVersionRequest: AWSEncodableShape {
        public static var _encoding = [
            AWSMemberEncoding(label: "clusterName", location: .uri(locationName: "name")),
            AWSMemberEncoding(label: "nodegroupName", location: .uri(locationName: "nodegroupName"))
        ]

        /// Unique, case-sensitive identifier that you provide to ensure the idempotency of the request.
        public let clientRequestToken: String?
        /// The name of the Amazon EKS cluster that is associated with the managed node group to update.
        public let clusterName: String
        /// Force the update if the existing node group's pods are unable to be drained due to a pod disruption budget issue. If an update fails because pods could not be drained, you can force the update after it fails to terminate the old node whether or not any pods are running on the node.
        public let force: Bool?
        /// An object representing a node group's launch template specification. You can only update a node group using a launch template if the node group was originally deployed with a launch template.
        public let launchTemplate: LaunchTemplateSpecification?
        /// The name of the managed node group to update.
        public let nodegroupName: String
        /// The AMI version of the Amazon EKS optimized AMI to use for the update. By default, the latest available AMI version for the node group's Kubernetes version is used. For more information, see Amazon EKS optimized Amazon Linux 2 AMI versions  in the Amazon EKS User Guide. If you specify launchTemplate, and your launch template uses a custom AMI, then don't specify releaseVersion, or the node group update will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let releaseVersion: String?
        /// The Kubernetes version to update to. If no version is specified, then the Kubernetes version of the node group does not change. You can specify the Kubernetes version of the cluster to update the node group to the latest AMI version of the cluster's Kubernetes version. If you specify launchTemplate, and your launch template uses a custom AMI, then don't specify version, or the node group update will fail. For more information about using launch templates with Amazon EKS, see Launch template support in the Amazon EKS User Guide.
        public let version: String?

        public init(clientRequestToken: String? = UpdateNodegroupVersionRequest.idempotencyToken(), clusterName: String, force: Bool? = nil, launchTemplate: LaunchTemplateSpecification? = nil, nodegroupName: String, releaseVersion: String? = nil, version: String? = nil) {
            self.clientRequestToken = clientRequestToken
            self.clusterName = clusterName
            self.force = force
            self.launchTemplate = launchTemplate
            self.nodegroupName = nodegroupName
            self.releaseVersion = releaseVersion
            self.version = version
        }

        private enum CodingKeys: String, CodingKey {
            case clientRequestToken
            case force
            case launchTemplate
            case releaseVersion
            case version
        }
    }

    public struct UpdateNodegroupVersionResponse: AWSDecodableShape {
        public let update: Update?

        public init(update: Update? = nil) {
            self.update = update
        }

        private enum CodingKeys: String, CodingKey {
            case update
        }
    }

    public struct UpdateParam: AWSDecodableShape {
        /// The keys associated with an update request.
        public let type: UpdateParamType?
        /// The value of the keys submitted as part of an update request.
        public let value: String?

        public init(type: UpdateParamType? = nil, value: String? = nil) {
            self.type = type
            self.value = value
        }

        private enum CodingKeys: String, CodingKey {
            case type
            case value
        }
    }

    public struct VpcConfigRequest: AWSEncodableShape {
        /// Set this value to true to enable private access for your cluster's Kubernetes API server endpoint. If you enable private access, Kubernetes API requests from within your cluster's VPC use the private VPC endpoint. The default value for this parameter is false, which disables private access for your Kubernetes API server. If you disable private access and you have nodes or AWS Fargate pods in the cluster, then ensure that publicAccessCidrs includes the necessary CIDR blocks for communication with the nodes or Fargate pods. For more information, see Amazon EKS Cluster Endpoint Access Control in the  Amazon EKS User Guide .
        public let endpointPrivateAccess: Bool?
        /// Set this value to false to disable public access to your cluster's Kubernetes API server endpoint. If you disable public access, your cluster's Kubernetes API server can only receive requests from within the cluster VPC. The default value for this parameter is true, which enables public access for your Kubernetes API server. For more information, see Amazon EKS Cluster Endpoint Access Control in the  Amazon EKS User Guide .
        public let endpointPublicAccess: Bool?
        /// The CIDR blocks that are allowed access to your cluster's public Kubernetes API server endpoint. Communication to the endpoint from addresses outside of the CIDR blocks that you specify is denied. The default value is 0.0.0.0/0. If you've disabled private endpoint access and you have nodes or AWS Fargate pods in the cluster, then ensure that you specify the necessary CIDR blocks. For more information, see Amazon EKS Cluster Endpoint Access Control in the  Amazon EKS User Guide .
        public let publicAccessCidrs: [String]?
        /// Specify one or more security groups for the cross-account elastic network interfaces that Amazon EKS creates to use to allow communication between your nodes and the Kubernetes control plane. If you don't specify any security groups, then familiarize yourself with the difference between Amazon EKS defaults for clusters deployed with Kubernetes:   1.14 Amazon EKS platform version eks.2 and earlier   1.14 Amazon EKS platform version eks.3 and later    For more information, see Amazon EKS security group considerations in the  Amazon EKS User Guide .
        public let securityGroupIds: [String]?
        /// Specify subnets for your Amazon EKS nodes. Amazon EKS creates cross-account elastic network interfaces in these subnets to allow communication between your nodes and the Kubernetes control plane.
        public let subnetIds: [String]?

        public init(endpointPrivateAccess: Bool? = nil, endpointPublicAccess: Bool? = nil, publicAccessCidrs: [String]? = nil, securityGroupIds: [String]? = nil, subnetIds: [String]? = nil) {
            self.endpointPrivateAccess = endpointPrivateAccess
            self.endpointPublicAccess = endpointPublicAccess
            self.publicAccessCidrs = publicAccessCidrs
            self.securityGroupIds = securityGroupIds
            self.subnetIds = subnetIds
        }

        private enum CodingKeys: String, CodingKey {
            case endpointPrivateAccess
            case endpointPublicAccess
            case publicAccessCidrs
            case securityGroupIds
            case subnetIds
        }
    }

    public struct VpcConfigResponse: AWSDecodableShape {
        /// The cluster security group that was created by Amazon EKS for the cluster. Managed node groups use this security group for control-plane-to-data-plane communication.
        public let clusterSecurityGroupId: String?
        /// This parameter indicates whether the Amazon EKS private API server endpoint is enabled. If the Amazon EKS private API server endpoint is enabled, Kubernetes API requests that originate from within your cluster's VPC use the private VPC endpoint instead of traversing the internet. If this value is disabled and you have nodes or AWS Fargate pods in the cluster, then ensure that publicAccessCidrs includes the necessary CIDR blocks for communication with the nodes or Fargate pods. For more information, see Amazon EKS Cluster Endpoint Access Control in the  Amazon EKS User Guide .
        public let endpointPrivateAccess: Bool?
        /// This parameter indicates whether the Amazon EKS public API server endpoint is enabled. If the Amazon EKS public API server endpoint is disabled, your cluster's Kubernetes API server can only receive requests that originate from within the cluster VPC.
        public let endpointPublicAccess: Bool?
        /// The CIDR blocks that are allowed access to your cluster's public Kubernetes API server endpoint. Communication to the endpoint from addresses outside of the listed CIDR blocks is denied. The default value is 0.0.0.0/0. If you've disabled private endpoint access and you have nodes or AWS Fargate pods in the cluster, then ensure that the necessary CIDR blocks are listed. For more information, see Amazon EKS Cluster Endpoint Access Control in the  Amazon EKS User Guide .
        public let publicAccessCidrs: [String]?
        /// The security groups associated with the cross-account elastic network interfaces that are used to allow communication between your nodes and the Kubernetes control plane.
        public let securityGroupIds: [String]?
        /// The subnets associated with your cluster.
        public let subnetIds: [String]?
        /// The VPC associated with your cluster.
        public let vpcId: String?

        public init(clusterSecurityGroupId: String? = nil, endpointPrivateAccess: Bool? = nil, endpointPublicAccess: Bool? = nil, publicAccessCidrs: [String]? = nil, securityGroupIds: [String]? = nil, subnetIds: [String]? = nil, vpcId: String? = nil) {
            self.clusterSecurityGroupId = clusterSecurityGroupId
            self.endpointPrivateAccess = endpointPrivateAccess
            self.endpointPublicAccess = endpointPublicAccess
            self.publicAccessCidrs = publicAccessCidrs
            self.securityGroupIds = securityGroupIds
            self.subnetIds = subnetIds
            self.vpcId = vpcId
        }

        private enum CodingKeys: String, CodingKey {
            case clusterSecurityGroupId
            case endpointPrivateAccess
            case endpointPublicAccess
            case publicAccessCidrs
            case securityGroupIds
            case subnetIds
            case vpcId
        }
    }
}
